package com.wuzhiming.istudy.controller;

import com.alibaba.fastjson.JSONObject;
import com.wuzhiming.istudy.pojo.*;
import com.wuzhiming.istudy.pojo.Collection;
import com.wuzhiming.istudy.service.CourseTypeService;
import com.wuzhiming.istudy.utils.LogUtils;
import org.slf4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @ClassName: SystemController
 * @Description: 系统前端首页控制器
 * @Author:zhimingw
 * @Version 1.0
 * @since 2022/2/25 17:01
 */
@Controller
public class SystemController extends BaseController{
    private Logger logger = LogUtils.getInstance(AdminController.class);
    /**
     * 前往 后台登录页面
     */
    @GetMapping("/toAdminLoginPage")
    public  String toAdminLoginPage(Map<String,Object> map){
        return "login";
    }
    /**
     * 前往 前台首页
     */
    @GetMapping({"/","/index"})
    public String index(Map<String,Object> map, Integer courseTypeId){
        if(courseTypeId==null){
            courseTypeId = 2;
        }
        // 更新/新增 访问数据
        statisticsService.update(request,-1);
        //查询所有课程类别
        List<CourseType> courseTypes = courseTypeService.queryAll();
        //查询所有课程阶段
        List<CourseStage> courseStages = courseStageService.queryAllById(courseTypeId);
        //查询所有所有课程
        List<Course> courses = courseService.queryAllByTypeId(courseTypeId);
        map.put("courseTypes",courseTypes);
        map.put("courseStages",courseStages);
        map.put("courses",courses);
        map.put("userInfo",userInfo);
        return "front/index";
    }

    /***
    * @Description: 前往 课程详情页面
    * @Param: [id, map]
    * @return: java.lang.String
    * @Author: zhimingw
    * @Date: 2022/3/6
    */
    @GetMapping("/courseDetail")
    public String course(@RequestParam("id") Integer id,Map<String,Object> map){
        //查询课程详情
        Course course = courseService.queryById(id);
        //更改该课程浏览次数
        courseService.update(new Course(id,0));
        //查询该课程下所有评论
        List<Comment> comments = commentService.queryCommentById(id);
        //更新/新增 访问数据
        statisticsService.update(request,id);
        List<Collection> collections = null;
        boolean isCollection = true;
        if(userInfo!=null){
            //查询用户是否收藏过该课程
            Collection collection = new Collection(userInfo.getId(),id,1);
            collections = collectionService.getCollection(collection);
        }
        if(collections!=null && collections.size()>0){
            isCollection = false;
        }
        map.put("course",course);
        map.put("comments",comments);
        map.put("isCollection",isCollection);
        map.put("userInfo",userInfo);
        return "front/courseDetail";
    }

    //进入用户个人中心
    @GetMapping("/personalCenter")
    public String personalCenter(Map<String,Object> map){
        if(userInfo==null){
            return "redirect:/index";
        }
        Collection collection = new Collection(userInfo.getId(),1);
        //获得个人收藏课程数据
        List<Collection> collections = collectionService.getCollection(collection);
        map.put("collections",collections);
        //获得个人评论课程数据
        Comment comment = new Comment(userInfo.getId(), 1);
        List<Comment> commentList = commentService.getUserComment(comment);
        List<Course> courseList = new ArrayList<>(); //要将重复的课程去掉,将同一课程的评论放在一起
        if(commentList.size()>0){
            Map<String, Course> courseMap = new HashMap<>();
            for(int i=0;i<commentList.size();i++){
                courseMap.put(commentList.get(i).getCourse().getTitle(),commentList.get(i).getCourse());
            }
            for(Map.Entry<String,Course> entry: courseMap.entrySet()){
                courseList.add(entry.getValue());
            }
        }

        //请求用户笔记数据
        List<Note> userNotes = noteService.getUserNote(new Note(userInfo.getId(), 1));

        map.put("courseList",courseList);
        map.put("commentList",commentList);
        map.put("userNotes",userNotes);
        //获得用户个人信息
        map.put("userInfo",userInfo);
        return "front/personalCenter";
    }


    /**
    * @Description: 前往 后台仪表盘页面
    * @Param: [map]
    * @return: java.lang.String
    * @Author: zhimingw
    * @Date: 2022/3/28
    */
    @GetMapping("/dashboard")
    public  String dashboard(Map<String,Object> map){
        // 获取各个状态下课程的数量
        Map<String, Integer> countMap = statusCount();
        // 获取发布数
        map.put("publishCount",countMap.get("publish"));
        // 获取草稿数
        map.put("draftCount",countMap.get("draft"));
        // 获取回收站数
        map.put("trashCount",countMap.get("trash"));
        // 获取评论数
        map.put("commentCount",commentService.getCount(1));
        // 获取课程类别数
        map.put("courseTypeCount",courseTypeService.getCount(1));
        // 获取课程阶段数
        map.put("courseStageCount",courseStageService.getCount(1));
        // 获取统计信息
        map.put("statistics",statisticsService.getVisitStatistics());
        // 获取统计数量信息
        map.put("statisticsCount",statisticsService.getStatisticsCount());
        return "admin/dashboard";
    }

    /**
     * @Description: 前往 后台-统计
     * @Param: [map]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2021/7/11
     */
    @GetMapping("/statistics")
    public String statistics(Map<String,Object> map){
        logger.warn("请求【后台-统计】页面");
        // 获取统计信息
        map.put("statistics",statisticsService.getVisitStatistics());
        // 获取所有访客信息
        map.put("visitors",statisticsService.getVisitorStatistics());
        // 获取统计数量信息
        map.put("statisticsCount",statisticsService.getStatisticsCount());
        // 获取未读评论数
        return "admin/statistics";
    }

    /**
     * @Description: 获取各种状态下的数量
     * @Param: []
     * @return: java.util.Map<java.lang.String,java.lang.Integer>
     * @Author: zhimingw
     * @Date: 2021/7/6
     */
    public Map<String,Integer> statusCount(){
        Map<String,Integer> map = new HashMap<>();
        Integer draft = courseService.totalCount(0);
        Integer publish = courseService.totalCount(1);
        Integer trash = courseService.totalCount(2);
        map.put("draft",draft);
        map.put("publish",publish);
        map.put("trash",trash);
        return map;
    }

    /**
     * @Description: 前往 管理员我的资料页面
     * @Param: [map]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2021/7/11
     */
    @GetMapping("/profile")
    public String profile(Map<String,Object> map){
        return "admin/profile";
    }

    /**
     * @Description: 前往 所有课程页面
     * @Param: [map, type]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2021/7/11
     */
    @GetMapping("/courses")
    public String articles(Map<String,Object> map,String type){
        List<Course> courses = new ArrayList<>();
        type = type==null?"publish":type;
        if("publish".equals(type)){
            logger.warn("请求【已发表文章】页面");
            courses = courseService.queryByStatus(1);
        }else if("draft".equals(type)){
            logger.warn("请求【草稿文章】页面");
            courses = courseService.queryByStatus(0);
        }else if ("trash".equals(type)){
            logger.warn("请求【回收站】页面");
            courses = courseService.queryByStatus(2);
        }else {
            return "error/400";
        }
        map.put("courses",courses);
        //获取各个状态下课程的数量
        map.put("statusCount",statusCount());
        return "admin/"+type;
    }

    /**
     * @Description: 前往 发布课程/编辑课程页面
     * @Param: [map, id]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2021/7/21
     */
    @GetMapping("/edit")
    public String edit(Map<String,Object> map,Integer id){
        // 获取全部的课程分类
        List<CourseType> courseTypes = courseTypeService.queryAll();
        map.put("courseTypes",courseTypes);
        if(id==null){
            logger.warn("请求【发布课程】页面");
            return "admin/new";
        }else{
            logger.warn("请求【编辑课程】页面，ID："+id);
            //获取文章对象
            Course course = courseService.queryById(id);
            map.put("course",course);
            return "admin/edit";
        }
    }

    /**
     * @Description: 前往 所有课程类型页面
     * @Param: [map]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2021/7/11
     */
    @GetMapping("/types")
    public String types(Map<String,Object> map){
        logger.warn("请求【所有课程类型】页面");
        //获取所有的课程类型
        List<CourseType> courseTypes = courseTypeService.queryAll();
        Integer count = courseTypeService.getCount(1);
        map.put("count",count);
        map.put("courseTypes",courseTypes);
        return "admin/types";
    }

    /**
     * @Description: 前往 编辑课程类别页面
     * @Param: [map, id]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2021/7/16
     */
    @GetMapping("/courseType")
    public String courseType(Map<String,Object> map,Integer id){
        logger.warn("请求【编辑课程类别】页面");
        if(id==null){
            return "redirect:/types";
        }
        CourseType courseType = courseTypeService.queryById(id);
        if(courseType==null){
            return "redirect:/types";
        }
        map.put("type",courseType);
        return "admin/type";
    }

    /**
     * @Description: 前往 所有课程阶段页面
     * @Param: [map]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2021/7/11
     */
    @GetMapping("/stages")
    public String tags(Map<String,Object> map){
        logger.warn("请求【所有课程阶段】页面");
        // 获取全部的课程分类
        List<CourseType> courseTypes = courseTypeService.queryAll();
        map.put("courseTypes",courseTypes);
        List<CourseStage> stages = courseStageService.queryAll();
        map.put("stages",stages);
        // 获取未读评论数
        return "admin/stages";
    }

    /**
     * @Description: 前往 编辑标签页面
     * @Param: [map, id]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2021/7/20
     */
    @GetMapping("/stage")
    public String tag(Map<String,Object> map,Integer id){
        logger.warn("请求【编辑课程阶段】页面");
        // 如果id为空那么重定向到所有课程阶段页面
        if (id == null){
            return "redirect:/stages";
        }
        // 获取全部的课程分类
        List<CourseType> courseTypes = courseTypeService.queryAll();
        map.put("courseTypes",courseTypes);
        // 获取此标签
        CourseStage stage = courseStageService.queryById(id);
        if (stage == null){
            return "redirect:/stages";
        }
        map.put("stage",stage);
        return "admin/stage";
    }


    /**
     * @Description: 前往 所有评论页面
     * @Param: [map]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2021/7/7
     */
    @GetMapping("/comments")
    public String comments(Map<String,Object> map){
        logger.warn("请求【所有评论】页面");
        List<Comment> comments = commentService.queryAll();
        map.put("comments",comments);
        //获取未评论数
        return "admin/comments";
    }

    /**
     * @Description: 前往 所有用户页面
     * @Param: [map]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2021/7/7
     */
    @GetMapping("/users")
    public String users(Map<String,Object> map){
        logger.warn("请求【所有用户】页面");
        List<User> users = userService.queryAll();
        map.put("users",users);
        //获取未评论数
        return "admin/users";
    }

    /***
     * @Description: 前往 推荐用户课程(根据用户评论和收藏)
     * @Param: [id, map]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2022/3/6
     */
    @GetMapping("/recommend")
    public String recommend(@RequestParam("id") Integer id,Map<String,Object> map){
        //获得个人评论课程数据
        Comment comment = new Comment(id, 1);
        List<Comment> commentList = commentService.getUserComment(comment);
        //获得个人收藏课程数据
        Collection collection = new Collection(id,1);
        List<Collection> collections = collectionService.getCollection(collection);
        List<Course> hotCourses = new ArrayList<>();
        if(commentList.size()==0&&collections.size()==0){//如果用户第一次注册/登录系统就推荐浏览量最多前5的课程
            hotCourses = courseService.getHotCourse();
        }else{//用户收藏过评论过某些课程，推荐该课程阶段
            //先获得收藏、评论数据下所有课程阶段id
            Set<Integer> stageIdSet = new HashSet<>();
            List<CourseStage> courseStages = new ArrayList<>();
            for(int i=0;i<commentList.size();i++){
                stageIdSet.add(commentList.get(i).getCourse().getCourseStageId());
            }
            for(int i=0;i<collections.size();i++){
                stageIdSet.add(collections.get(i).getCourse().getCourseStageId());
            }
            //再获得对应课程阶段下所有课程
            for(Integer stageId:stageIdSet){
                //设置对应课程阶段
                CourseStage courseStage = courseStageService.queryById(stageId);
                courseStages.add(courseStage);
                List<Course> courseByStageId = courseService.getCourseByStageId(stageId);
                hotCourses.addAll(courseByStageId);
            }
            map.put("courseStages",courseStages);
        }
        //查询所有课程类别
        List<CourseType> courseTypes = courseTypeService.queryAll();
        map.put("courseTypes",courseTypes);
        map.put("userInfo",userInfo);
        map.put("hotCourses",hotCourses);
        return "front/recommend";
    }

    /**
     * @Description: 前往 写笔记页面
     * @Param: [map]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2021/7/7
     */
    @GetMapping("/notes")
    public String notes(Integer id,Map<String,Object> map){
        logger.warn("请求【写笔记】页面");
        if(userInfo==null){
            return "error/401";
        }
        Note note = new Note();
        if(id!=null){//更改笔记信息
            note = noteService.getNoteDetail(id);
        }
        map.put("note",note);
        return "front/notes";
    }

    /**
     * @Description: 前往 搜索课程页面
     * @Param: [map, content, tagId, kindId, data]
     * @return: java.lang.String
     * @Author: zhimingw
     * @Date: 2021/6/30
     */
    @GetMapping("/search")
    public String search(Map<String,Object> map,String content){
        List<Course> courses = null;
        //查询所有课程类别
        List<CourseType> courseTypes = courseTypeService.queryAll();
        if(!ObjectUtils.isEmpty(content)){
            logger.warn("请求【搜索】页面，搜索内容："+content);
            //初始化es
            if(courseService.getEsDocCount()==0){
                logger.warn("检测到【ElasticSearch为空】开始初始化..");
                courseService.initEs();
            }
            courses = courseService.searchFromEs(content);
            map.put("content",content);
        }
        map.put("courses",courses);
        map.put("courseTypes",courseTypes);
        map.put("userInfo",userInfo);
        return "front/search";
    }
}
